home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_200 / 213_01 / unvanr.c < prev    next >
Encoding:
C/C++ Source or Header  |  1980-01-01  |  5.1 KB  |  289 lines
  1. /* UNVANR.C    VERS:- 01.00  DATE:- 09/26/86  TIME:- 09:37:29 PM */
  2. /*
  3. %CC1 $1.C -X -E6000
  4. %CLINK $1 DIO -S -E6000
  5. %DELETE $1.CRL 
  6. */
  7. /* 
  8. Description:
  9.  
  10. Filter to convert Van Nuys Toolkit format back to standard C tokens.
  11.  
  12. DIO redirection.
  13.  
  14. Adapted from Van Nuys Toolkit program CASE, by Eugene H. Mallory.
  15.  
  16. By J.A. Rupley, Tucson, Arizona
  17. Coded for BDS C compiler, version 1.50a
  18. */
  19.  
  20. #include "bdscio.h"
  21. #include "dio.h"
  22.  
  23. #define MAXNAMES 40
  24.  
  25. int lastchar;
  26. int preprocessor;
  27.  
  28. main(argc, argv)
  29.  
  30. char **argv;
  31. int argc;
  32.  
  33. {
  34.     char word[10000];
  35.     char delimiter[1];
  36.     int c;
  37.     int flag;
  38.     int i;
  39.  
  40.     char *keyword[MAXNAMES];
  41.     int keycount[MAXNAMES];
  42.  
  43.     i = 0;
  44.     /*
  45.         keyword[i++] = "flush";
  46.         keyword[i++] = "NOT";
  47.     */
  48.     keyword[i++] = "AND";        /*0*/
  49.     keyword[i++] = "OR";
  50.     keyword[i++] = "EQUAL";
  51.     keyword[i++] = "NOTEQUAL";
  52.     keyword[i++] = "BEGIN";
  53.     keyword[i++] = "THEN";        /*5*/
  54.     keyword[i++] = "LOOP";
  55.     keyword[i++] = "END";
  56.     keyword[i++] = "ENDIF";
  57.     keyword[i++] = "ENDLOOP";
  58.     keyword[i++] = "FUNCTION";        /*10*/
  59.  
  60.     keyword[i++] = "MAIN";
  61.     keyword[i++] = "CHAR";
  62.     keyword[i++] = "INT";
  63.     keyword[i++] = "REGISTER";
  64.     keyword[i++] = "STRUCT";
  65.     keyword[i++] = "UNION";
  66.     keyword[i++] = "UNSIGNED";
  67.     keyword[i++] = "BREAK";
  68.     keyword[i++] = "CONTINUE";
  69.     keyword[i++] = "DEFAULT";
  70.     keyword[i++] = "IF";
  71.     keyword[i++] = "ELSE";
  72.     keyword[i++] = "GOTO";
  73.     keyword[i++] = "DO";
  74.     keyword[i++] = "FOR";
  75.     keyword[i++] = "WHILE";
  76.     keyword[i++] = "RETURN";
  77.     keyword[i++] = "SIZEOF";
  78.     keyword[i++] = "SWITCH";
  79.     keyword[i++] = "CASE";
  80.     keyword[i++] = "DEFINE";
  81.     keyword[i++] = "IFDEF";
  82.     keyword[i++] = "IFNDEF";
  83.     keyword[i++] = "UNDEF";
  84.     keyword[i++] = "INCLUDE";
  85.     keyword[i++] = "$$$";
  86.  
  87.  
  88.     lastchar = 0;
  89.     for (i = 0; i < MAXNAMES; i++)
  90.         keycount[i] = 0;
  91.  
  92.     dioinit(&argc, argv);
  93.     if (!_dioinflg)
  94.     {
  95.         printf(
  96.         "\nUSAGE:\n");
  97.         printf(
  98.         "     unvanuys  <vanuys_fid  [>out_fid or |DIO_pipe or default = crt]\n\n");
  99.         printf(
  100.         "one of three formatting filters:\n\n");
  101.         printf(
  102.         "unvanuys - converts keywords of Van Nuys Toolkit to standard K & R 'c'\n");
  103.         printf(
  104.         "cbprep - produces consistent spacing of 'c' text and one statement per line\n");
  105.         printf(
  106.         "         output must be filtered by cb\n");
  107.         printf(
  108.         "cb - indents according to control level\n\n");
  109.         dioexit();
  110.     }
  111.  
  112.     do
  113.         {
  114.         flag = get_word(word, delimiter);
  115.         if (preprocessor)
  116.         {
  117.             lower_case(word);
  118.             puts(word);
  119.             if (flag)
  120.                 putchar(delimiter[0]);
  121.             continue;
  122.         }
  123.         for (i = 0; i < MAXNAMES; i++)
  124.         {
  125.             if (strequ(keyword[i], "$$$"))
  126.                 break;
  127.             if (strequ(keyword[i], word))
  128.             {
  129.                 keycount[i]++;
  130.                 switch (i)
  131.                 {
  132.                 case 0 :
  133.                     strcpy(word, "&&");
  134.                     break;
  135.                 case 1 :
  136.                     strcpy(word, "||");
  137.                     break;
  138.                 case 2 :
  139.                     strcpy(word, "==");
  140.                     break;
  141.                 case 3 :
  142.                     strcpy(word, "!=");
  143.                     break;
  144.                 case 4 :
  145.                 case 5 :
  146.                 case 6 :
  147.                     strcpy(word, "{");
  148.                     break;
  149.                 case 7 :
  150.                 case 8 :
  151.                 case 9 :
  152.                     strcpy(word, "}");
  153.                     break;
  154.                 case 10 :
  155.                     strcpy(word, "");
  156.                     break;
  157.                 default :
  158.                     lower_case(word);
  159.                 }
  160.                 break;
  161.             }
  162.         }
  163.         puts(word);
  164.         if (flag)
  165.             putchar(delimiter[0]);
  166.     }
  167.     while (flag)
  168.         ;
  169.  
  170.     for (i = 0; i < MAXNAMES; i++)
  171.     {
  172.         if (strequ(keyword[i], "$$$"))
  173.             break;
  174.         if (keycount[i])
  175.         {
  176.             typef("%7d %ss\n", keycount[i], keyword[i]);
  177.         }
  178.     }
  179.     dioflush();
  180. }
  181.  
  182.  
  183. int get_word(cptr, dptr)
  184. char *cptr, *dptr;
  185. {
  186.     int c;
  187.     int nest;
  188.     int cptr_start;
  189.  
  190.     cptr_start = cptr;
  191.     nest = 0;
  192.     if (lastchar == '#')
  193.         preprocessor = 1;
  194.     else
  195.         preprocessor = 0;
  196. lup :
  197.     c = getchar();
  198.     if (c == EOF)
  199.     {
  200.         *cptr++ = 0;
  201.         *dptr = CPMEOF;
  202.         return 0;
  203.     }
  204.     if (lastchar == '/' && c == '*')
  205.     {
  206.         lastchar = 0;
  207.         while ((c != '/') || (lastchar != '*') || (nest > 0))
  208.         {
  209.             if ((lastchar == '/') && (c == '*'))
  210.                 nest++;
  211.             if ((lastchar == '*') && (c == '/'))
  212.                 nest--;
  213.             *cptr++ = c;
  214.             lastchar = c;
  215.             c = getchar();
  216.         }
  217.         *cptr++ = c;
  218.         goto lup;
  219.     }
  220.     if (c == '"')
  221.     {
  222.         lastchar = '\\';
  223.         while (c != '"' || lastchar == '\\')
  224.         {
  225.             *cptr++ = c;
  226.             lastchar = c;
  227.             c = getchar();
  228.         }
  229.         *cptr++ = c;
  230.         if (c == '\\' && lastchar == '\\')
  231.         {
  232.             *cptr++ = c;
  233.             lastchar = 0;
  234.             c = getchar();
  235.         }
  236.         goto lup;
  237.     }
  238.  
  239.     if (c == '\'')
  240.     {
  241.         lastchar = '\\';
  242.         while (c != '\'' || lastchar == '\\')
  243.         {
  244.             *cptr++ = c;
  245.             lastchar = c;
  246.             c = getchar();
  247.             if (c == '\\' && lastchar == '\\')
  248.             {
  249.                 *cptr++ = c;
  250.                 lastchar = 0;
  251.                 c = getchar();
  252.             }
  253.         }
  254.         *cptr++ = c;
  255.         goto lup;
  256.     }
  257.  
  258.     if (isalpha(c) || c == '_' || isdigit(c))
  259.     {
  260.         *cptr++ = c;
  261.         goto lup;
  262.     }
  263.     *cptr++ = 0;
  264.     *dptr = c;
  265.     lastchar = c;
  266.     return 1;
  267. }
  268.  
  269.  
  270. void lower_case(cptr)
  271. char *cptr;
  272. {
  273.     while (*cptr != 0)
  274.     {
  275.         *cptr = tolower(*cptr);
  276.         cptr++;
  277.     }
  278. }
  279.  
  280.  
  281. strequ(s1, s2)
  282. char *s1, *s2;
  283. {
  284.     while (toupper(*s1++) == toupper(*s2++))
  285.         if (!*s1 && !*s2)
  286.             return (1);
  287.     return (0);
  288. }
  289.